widget: Hook GTK_PHASE_TARGET controllers to the default event handlers

Just call the controllers on that phase if the default widget handlers
are run.

For compatibility reasons, in the touch event handler, let the pointer
emulating touch be transformed to a pointer event as usual, in order to
have widget handlers a chance to run at all. If they have to be managed
by a controller in that phase, it'll have to be through the default pointer
event handlers.

gesture: Add GTK_PHASE_TARGET

This phase is meant to run in the default widget handlers, as opposed
to externally as in the bubble/capture phase. This will be most usually
the expected phase for every controller replacing code in event handlers
in GTK+, just so invocation and triggering order is kept unaltered.

gesture: Handle GdkEventGrabBroken

That may happen separately from grab-notify, and also due to external
reasons, so ensure all sequences are cancelled if a grab is taken
in some GdkWindows that would obscure events on the controller.

GtkColorSwatch: Use gesture for button events too

GtkWindow: Only use a multipress gesture for toplevels

There is no point in creating and attaching this gesture
for override-redirect windows, so don't do it.

Be careful about the list of event controllers

We can end up with _gtk_widget_remove_controller getting called
while we are iterating over the list in _gtk_widget_run_controllers.
To avoid trouble, only mark the event controller as dead by
setting data->controller to NULL, and defer the actual freeing
and list manipulation to the loop in _gtk_widget_run_controllers.
Update other places that operate on controllers to handle
data->controller being NULL.

textview: Convert gestures' coordinates to text window ones

And make some code shared between multipress/drag gesture.

textview: Use GtkGestureDrag for text selection/DnD

remaining code in button press/release, motion notify, and grab
notify handlers has been shuffled to be managed by this gesture.

textview: Use GtkGestureMultiPress for click handling

The button press handler is no longer necessary, and most of its
code has been shuffled into the GtkGestureMultiPress::pressed
handler.

widget: tighten the conditions at which a press event is emulated

Make it really sure that the event is only emitted after every gesture
that consumed the button press is done with the sequence.
The event must only be emulated if a gesture in the capture phase happened
to consume the event, be cancelled, and

widget: Fix gesture event handler retval for bubbled events

Do not clobber the return value if the regular event handler happens
to return FALSE, even if the gesture meant to consume the event.

gesture: Prevent against sequence cancellation within gtk_gesture_set_state()

Sequences may be cancelled within the ::sequence-state-changed handler, which
would change the points hashtable as it's being iterated in this function. So
iterate over a list of sequences and let the hashtable change freely.

gesture: Make gtk_gesture_get_last_update_time() private

gesture: Remove gtk_gesture_get_last_event_type

gesture: make gtk_gesture_cancel_sequence() private

gesture: Make gtk_gesture_check() private

dnd: Check on the right gesture sequence when starting the drag op

gesture: Simplify gesture/widget interaction public API

The propagation phase property/methods in GtkEventController are gone,
This is now set directly on the GtkWidget add/remove controller API,
which has been made private.

The only public bit now are the new functions gtk_gesture_attach() and
gtk_gesture_detach() that will use the private API underneath.

All callers have been updated.

widget: Keep a widget reference around _gtk_widget_run_controllers()

The widget may be destroyed within the loop, in reaction to the signals
sent by the controllers. Protect against that.

gesture: Add explanatory note in GtkGesture::end

Explain that this signal may be triggered by an extra touch that causes
the gesture to surpass GtkGesture:n-points.

gesture: Cancel sequences that make a gesture exceed the number of touches as they happen

This makes it possible to track those through gtk_gesture_handles_sequence(),
without guessing from last event type or sequence state.

widget: Change slightly the gesture cancellation policy in a same widget

Within a widget, if a gesture accepts a sequence, it would previously
cancel every other gesture that not in the same group. Change this to
only cancelling gestures that previously claimed the gesture, and let
gestures with state=NONE for that sequence remain like that.

This enables late recognition of gestures, even on the presence of
another gesture group that was more eager at claiming the gesture.

One usecase is user-defined panning gestures on scrolledwindows,
if ::capture-button-press is TRUE (eg. the default), the gesture is
claimed early in order to consume the button press, but that would
tipically make every other gesture group deny the sequence. With
this change, the pan gesture can keep state=NONE, and later claim
the sequence for itself if the panning gesture is recognized.

Also, do not propagate state=DENIED to every gesture in the widget,
that was unintended.

rotate: Ensure delta is between [0..2π]

pan: make the direction factor less narrow in v/h directions

gesture: Handle GDK_TOUCH_CANCEL events

The wayland windowing backend emits such events for instance, so
have gestures cancel the sequence as those events get through.

gesture: Protect against odd window hierarchies

If no match is found with the gesture widget when poking the event
window parents, bail out safely instead of falling in an infinite
loop. This was seen on Mutter.

swipe: Don't emit ::swipe if there are still active touches

Avoids sending spurious signals when an extra touch happens.

Prevent subclassing of gestures

For now, at least. We do this by hiding the instance and
class structures in private headers.

GtkSpinButton: Don't leak the gestures

GtkWindow: Don't leak the gesture

GtkTreeView: Remove unused field

gtk3-demo: Don't leak the color chooser

GtkColorPlane: Actually add the long press gesture

This was missed because gtk_widget_remove_controller silently
does nothing on unowned controllers.

GtkButton: Don't leak the gesture

Forgotten file

GtkButton: Port to GtkGesture

Quick-and-dirty patch to use a GtkGestureSingle for both
button press/release and touch event handling.

widget: remove GtkGesture-related signals

The utility of those signals is somewhat dubious now that there is
gtk_gesture_group(), so make that the only way to coordinate gestures.
The cooperation model offered by gtk_gesture_group() is flexible
enough,

docs: Add missing GtkEventController functions

widget: Add docs for GtkGesture-related API

gesturesingle: doc fixes

zoom: doc fixes

swipe: doc fixes

rotate: doc fixes

pan: doc fixes

multipress: doc fixes

longpress: doc fixes

drag: doc fixes

gesture: doc fixes

eventcontroller: doc fixes

docs: Add missing controller/gesture docs

pan: Add missing documentation

zoom: Add missing documentation

rotate: Add missing documentation

swipe: Add missing documentation

drag: Add missing documentation

longpress: Add missing documentation

multipress: Add missing documentation

gesturesingle: Add missing documentation

gesture: Add missing documentation

eventcontroller: Add missing documentation

enums: Add missing docs to controller/gesture enums

Remove GtkPressAndHold

This is replaced by GtkGestureLongPress, and all its callers have
been updated to use the replacement.

enums: Document GtkPropagationPhase

spinbutton: increase/decrease value on upwards/downwards touch swipes

This is somewhat analogous to scroll events on pointer devices, the
greater the velocity, the faster the spinbutton spins.

Add GtkGesturePan

This gesture reports events on horizontal/vertical panning gestures.

range: Replace GtkPressAndHold with GtkGestureLongPress

swipe: Add function to retrieve the current velocity

This can be used to fetch the current velocity on update(), as opposed
to swipe() which happens after the sequence is finished.

colorswatch: Replace GtkPressAndHold

GtkGestureLongPress and GtkGestureMultiPress are both used
to replace it.

colorscale: Replace GtkPressAndHold with GtkLongPressGesture

colorplane: Replace GtkPressAndHold with GtkLongPressGesture

entry: Don't show text handles too eagerly on button press

Instead do so on button release, or after text selection dragging
starts.

longpress: Ensure check() happens after cancel()

And delegate on GtkGesture::check(), it does deal better with
extra fleeting touches.

longpress: fix reentrancy on ::reset()

gesturemultipress: fix reentrancy on ::reset()

gesturesingle: check the current sequence before resetting the pressed button

scrolledwindow: update to gesture widget-level API changes

window: update to gesture widget-level API changes

treeview: update to gesture widget-level API changes

drag: remove unused #define

eventcontroller: Add documentation blurb

dnd: Update to gesture widget-level API changes

demo: Update to gesture widget-level API changes

widget: refactor gesture integration

Listen for notify::sequence-state-changed on the controller, so the
only way to manipulate a sequence state are gtk_gesture_set_sequence_state()
and gtk_gesture_set_state().

Also, make use of gesture groups, so the sequence state is set at once
on all gestures pertaining to a single group. Within a widget, if a sequence
is claimed on one group, it is made to be denied on every other group.

gesture: Add grouping API

This API eliminates the need for overriding
GtkWidget::sequence-state-changed virtually everywhere. Grouped
gestures share common states for a same GdkEventSequence, so the
state of sequences stay in sync across those.

gesture: Add gtk_gesture_set_state() helper.

This function sets the state on all sequences where it actually
can, just a helper function to avoid iterating over sequences
yourself.

gesture: emit the current state on ::sequence-state-changed

gesture: group continue conditions together

gesture: return TRUE if the sequence state was already set

gesture: fix compiler warning

gesture: ignore events if now widget window was found

eventcontroller: Add propagation-phase property

This is so we don't have to specify the capture phase for
every controller. The default "bubble" value will be sane
on most situations.

treeview: remove superfluous GTK+ grabs

textview: remove superfluous GTK+ grabs

iconview: remove superfluous GTK+ grabs

combobox: remove superfluous GTK+ grabs

cellrendereraccel: remove superfluous GTK+ grabs

Revert "gtk: Remove propagation limit of captured events on the grab widget"

This reverts commit 6511f411955adba4f960b8b07d39b93785afe33e.

longpress: Use xsettings to determine long press duration

GtkSettings::gtk-long-press-time is used to this effect.

settings: Add gtk-long-press-time setting

This setting determines the duration of a button/touch press to
be considered a long press.

window: Use gestures for window moving/resizing

A multipress gesture is used to control all this, replacing
single/double click custom code, and triggering window dragging
when the multipress is stopped, yet active (ie. the sequence remains
pressed).